FastAPI ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಆಳವಾಗಿ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. ಈ ಮಾರ್ಗದರ್ಶಿಯು ಕಸ್ಟಮ್ ಮಿಡಲ್‌ವೇರ್, ದೃಢೀಕರಣ, ಲಾಗಿಂಗ್, ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ದೃಢವಾದ API ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಪೈಥಾನ್ FastAPI ಮಿಡಲ್‌ವೇರ್: ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ
ಆಧುನಿಕ ವೆಬ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಜಗತ್ತಿನಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆ, ಭದ್ರತೆ ಮತ್ತು ನಿರ್ವಹಣಾ ಸಾಮರ್ಥ್ಯ ಬಹಳ ಮುಖ್ಯ. ಪೈಥಾನ್‌ನ FastAPI ಫ್ರೇಮ್‌ವರ್ಕ್ ತನ್ನ ಅದ್ಭುತ ವೇಗ ಮತ್ತು ಡೆವಲಪರ್-ಸ್ನೇಹಿ ವೈಶಿಷ್ಟ್ಯಗಳಿಗಾಗಿ ಶೀಘ್ರವಾಗಿ ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸಿದೆ. ಅದರ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಆದರೆ ಕೆಲವೊಮ್ಮೆ ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಿಕೊಳ್ಳುವ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಒಂದೆಂದರೆ ಮಿಡಲ್‌ವೇರ್. ಮಿಡಲ್‌ವೇರ್ ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಪ್ರೊಸೆಸಿಂಗ್ ಸರಪಳಿಯಲ್ಲಿ ನಿರ್ಣಾಯಕ ಕೊಂಡಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಡೆವಲಪರ್‌ಗಳು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ರಿಕ್ವೆಸ್ಟ್ ತನ್ನ ಗಮ್ಯಸ್ಥಾನವನ್ನು ತಲುಪುವ ಮೊದಲು ಅಥವಾ ರೆಸ್ಪಾನ್ಸ್ ಅನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸುವ ಮೊದಲು ನಿಯಮಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, FastAPI ಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವವರಿಂದ ಹಿಡಿದು ತಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಆಳವಾಗಿಸಲು ಬಯಸುವ ಅನುಭವಿ ವೃತ್ತಿಪರರವರೆಗೆ. ನಾವು ಮಿಡಲ್‌ವೇರ್‌ನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಕಸ್ಟಮ್ ಪರಿಹಾರಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ, ನೈಜ-ಪ್ರಪಂಚದ ಬಳಕೆಯ ಪ್ರಕರಣಗಳ ಮೂಲಕ ನಡೆಯುತ್ತೇವೆ. ಅಂತಿಮವಾಗಿ, ಹೆಚ್ಚು ದೃಢವಾದ, ಸುರಕ್ಷಿತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ API ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ನೀವು ಸಿದ್ಧರಾಗಿರುತ್ತೀರಿ.
ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಮಿಡಲ್‌ವೇರ್ ಎಂದರೇನು?
ಕೋಡ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ರಿಕ್ವೆಸ್ಟ್-ರೆಸ್ಪಾನ್ಸ್ ಚಕ್ರವನ್ನು ಪೈಪ್‌ಲೈನ್ ಅಥವಾ ಅಸೆಂಬ್ಲಿ ಲೈನ್ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ. ಕ್ಲೈಂಟ್ ನಿಮ್ಮ API ಗೆ ರಿಕ್ವೆಸ್ಟ್ ಕಳುಹಿಸಿದಾಗ, ಅದು ತಕ್ಷಣವೇ ನಿಮ್ಮ ಎಂಡ್ ಪಾಯಿಂಟ್ ಲಾಜಿಕ್‌ಗೆ ತಲುಪುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಪ್ರೊಸೆಸಿಂಗ್ ಹಂತಗಳ ಸರಣಿಯ ಮೂಲಕ ಪ್ರಯಾಣಿಸುತ್ತದೆ. ಅಂತೆಯೇ, ನಿಮ್ಮ ಎಂಡ್ ಪಾಯಿಂಟ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿದಾಗ, ಅದು ಕ್ಲೈಂಟ್ ತಲುಪುವ ಮೊದಲು ಈ ಹಂತಗಳ ಮೂಲಕ ಹಿಂತಿರುಗುತ್ತದೆ. ಮಿಡಲ್‌ವೇರ್ ಘಟಕಗಳು ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿನ ಈ ಹಂತಗಳಾಗಿವೆ.
ಒಂದು ಜನಪ್ರಿಯ ಉಪಮೆ ಈರುಳ್ಳಿ ಮಾದರಿ. ಈರುಳ್ಳಿಯ ತಿರುಳು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವ್ಯವಹಾರ ತರ್ಕವಾಗಿದೆ (ಎಂಡ್ ಪಾಯಿಂಟ್). ತಿರುಳನ್ನು ಸುತ್ತುವರೆದಿರುವ ಈರುಳ್ಳಿಯ ಪ್ರತಿ ಪದರವು ಒಂದು ಮಿಡಲ್‌ವೇರ್ ಆಗಿದೆ. ಕೋರ್ಗೆ ತಲುಪಲು ಒಂದು ರಿಕ್ವೆಸ್ಟ್ ಪ್ರತಿ ಹೊರ ಪದರವನ್ನು ಸುಲಿದು ಹೋಗಬೇಕು, ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಅದೇ ಪದರಗಳ ಮೂಲಕ ಹೊರಗೆ ಹೋಗುತ್ತದೆ. ಪ್ರತಿ ಪದರವು ರಿಕ್ವೆಸ್ಟ್ ಒಳಗೆ ಬರುವಾಗ ಅದನ್ನು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ಮಾರ್ಪಡಿಸಬಹುದು ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಹೊರಗೆ ಹೋಗುವಾಗ ಅದನ್ನು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ಮಾರ್ಪಡಿಸಬಹುದು.
ಸಾರಾಂಶದಲ್ಲಿ, ಮಿಡಲ್‌ವೇರ್ ಎನ್ನುವುದು ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್, ರೆಸ್ಪಾನ್ಸ್ ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ನ ರಿಕ್ವೆಸ್ಟ್-ರೆಸ್ಪಾನ್ಸ್ ಚಕ್ರದಲ್ಲಿ ಮುಂದಿನ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವ ಕಾರ್ಯ ಅಥವಾ ವರ್ಗವಾಗಿದೆ. ಇದರ ಪ್ರಾಥಮಿಕ ಉದ್ದೇಶಗಳು ಸೇರಿವೆ:
- ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು: ಪ್ರತಿ ಒಳಬರುವ ರಿಕ್ವೆಸ್ಟ್‌ಗಾಗಿ ಕ್ರಮಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು, ಉದಾಹರಣೆಗೆ ಲಾಗಿಂಗ್ ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆ ಮೇಲ್ವಿಚಾರಣೆ.
- ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದು: ಹೆಡರ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು, ರೆಸ್ಪಾನ್ಸ್ ಬಾಡಿಗಳನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವುದು ಅಥವಾ ಡೇಟಾ ಸ್ವರೂಪಗಳನ್ನು ಪರಿವರ್ತಿಸುವುದು.
- ಚಕ್ರವನ್ನು ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ಮಾಡುವುದು: ರಿಕ್ವೆಸ್ಟ್-ರೆಸ್ಪಾನ್ಸ್ ಚಕ್ರವನ್ನು ಮುಂಚಿತವಾಗಿ ಕೊನೆಗೊಳಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ದೃಢೀಕರಣ ಮಿಡಲ್‌ವೇರ್ ಅನಧಿಕೃತ ರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ಉದ್ದೇಶಿತ ಎಂಡ್ ಪಾಯಿಂಟ್ ಅನ್ನು ತಲುಪುವ ಮೊದಲು ನಿರ್ಬಂಧಿಸಬಹುದು.
- ಜಾಗತಿಕ ಕಾಳಜಿಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು: ದೋಷ ನಿರ್ವಹಣೆ, CORS (ಕ್ರಾಸ್-ಒರಿಜಿನ್ ರಿಸೋರ್ಸ್ ಶೇರಿಂಗ್) ಮತ್ತು ಸೆಷನ್ ನಿರ್ವಹಣೆಯಂತಹ ಅಡ್ಡ-ಕತ್ತರಿಸುವ ಕಾಳಜಿಗಳನ್ನು ಕೇಂದ್ರೀಕೃತ ಸ್ಥಳದಲ್ಲಿ ನಿರ್ವಹಿಸುವುದು.
FastAPI ಸ್ಟಾರ್ಲೆಟ್ ಟೂಲ್‌ಕಿಟ್‌ನ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಇದು ASGI (ಅಸಿಂಕ್ರೋನಸ್ ಸರ್ವರ್ ಗೇಟ್‌ವೇ ಇಂಟರ್ಫೇಸ್) ಮಾನದಂಡದ ದೃಢವಾದ ಅನುಷ್ಠಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮಿಡಲ್‌ವೇರ್ ASGI ಯಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ, ಇದು FastAPI ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಮೊದಲ ದರ್ಜೆಯ ನಾಗರಿಕನನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.
ಅತ್ಯಂತ ಸರಳ ರೂಪ: ಡಿಕೊರೇಟರ್‌ನೊಂದಿಗೆ FastAPI ಮಿಡಲ್‌ವೇರ್
FastAPI @app.middleware("http") ಡಿಕೊರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಸೇರಿಸಲು ನೇರವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಪ್ರತಿ HTTP ರಿಕ್ವೆಸ್ಟ್‌ಗೆ ರನ್ ಆಗಬೇಕಾದ ಸರಳ, ಸ್ವಯಂ-ಒಳಗೊಂಡಿರುವ ತರ್ಕಕ್ಕೆ ಸೂಕ್ತವಾಗಿದೆ.
ಒಂದು ಕ್ಲಾಸಿಕ್ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸೋಣ: ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್‌ಗೆ ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಮತ್ತು ಅದನ್ನು ರೆಸ್ಪಾನ್ಸ್ ಹೆಡರ್‌ಗಳಿಗೆ ಸೇರಿಸಲು ಮಿಡಲ್‌ವೇರ್. ಇದು ಕಾರ್ಯಕ್ಷಮತೆ ಮೇಲ್ವಿಚಾರಣೆಗೆ ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಉದಾಹರಣೆ: ಪ್ರೊಸೆಸ್-ಟೈಮ್ ಮಿಡಲ್‌ವೇರ್
ಮೊದಲಿಗೆ, ನೀವು FastAPI ಮತ್ತು Uvicorn ನಂತಹ ASGI ಸರ್ವರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೀರಾ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:
pip install fastapi uvicorn
ಈಗ, main.py ಎಂಬ ಫೈಲ್‌ನಲ್ಲಿ ಕೋಡ್ ಬರೆಯೋಣ:
import time
from fastapi import FastAPI, Request
app = FastAPI()
# Define the middleware function
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
# Record the start time when the request comes in
start_time = time.time()
# Proceed to the next middleware or the endpoint
response = await call_next(request)
# Calculate the processing time
process_time = time.time() - start_time
# Add the custom header to the response
response.headers["X-Process-Time"] = str(process_time)
return response
@app.get("/")
async def root():
# Simulate some work
time.sleep(0.5)
return {"message": "Hello, World!"}
ಈ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲು, ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:
uvicorn main:app --reload
ಈಗ, ನೀವು cURL ನಂತಹ ಟೂಲ್ ಅಥವಾ Postman ನಂತಹ API ಕ್ಲೈಂಟ್ ಬಳಸಿ http://127.0.0.1:8000 ಗೆ ರಿಕ್ವೆಸ್ಟ್ ಕಳುಹಿಸಿದರೆ, ರೆಸ್ಪಾನ್ಸ್‌ನಲ್ಲಿ ಸುಮಾರು 0.5 ಸೆಕೆಂಡುಗಳ ಮೌಲ್ಯದೊಂದಿಗೆ ಹೊಸ ಹೆಡರ್, X-Process-Time ಅನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ.
ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ:
@app.middleware("http"): ಈ ಡಿಕೊರೇಟರ್ ನಮ್ಮ ಕಾರ್ಯವನ್ನು HTTP ಮಿಡಲ್‌ವೇರ್‌ನ ಒಂದು ಭಾಗವಾಗಿ ನೋಂದಾಯಿಸುತ್ತದೆ.async def add_process_time_header(request: Request, call_next):: ಮಿಡಲ್‌ವೇರ್ ಕಾರ್ಯವು ಅಸಿಂಕ್ರೋನಸ್ ಆಗಿರಬೇಕು. ಇದು ಒಳಬರುವRequestಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ವಿಶೇಷ ಕಾರ್ಯವಾದcall_nextಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.response = await call_next(request): ಇದು ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಸಾಲು.call_nextರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಮುಂದಿನ ಹಂತಕ್ಕೆ (ಬೇರೊಂದು ಮಿಡಲ್‌ವೇರ್ ಅಥವಾ ನಿಜವಾದ ಪಾತ್ ಆಪರೇಷನ್) ರವಾನಿಸುತ್ತದೆ. ನೀವು ಅನಿವಾರ್ಯವಾಗಿ `await` ಮಾಡಬೇಕು ಈ ಕರೆಯನ್ನು. ಫಲಿತಾಂಶವು ಎಂಡ್ ಪಾಯಿಂಟ್‌ನಿಂದ ಉತ್ಪತ್ತಿಯಾದResponseಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ.response.headers[...] = ...: ಎಂಡ್ ಪಾಯಿಂಟ್‌ನಿಂದ ರೆಸ್ಪಾನ್ಸ್ ಸ್ವೀಕರಿಸಿದ ನಂತರ, ನಾವು ಅದನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕಸ್ಟಮ್ ಹೆಡರ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ.return response: ಅಂತಿಮವಾಗಿ, ಮಾರ್ಪಡಿಸಿದ ರೆಸ್ಪಾನ್ಸ್ ಅನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸಲು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
ವರ್ಗಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮದೇ ಆದ ಕಸ್ಟಮ್ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ರಚಿಸುವುದು
ಡಿಕೊರೇಟರ್ ವಿಧಾನವು ಸರಳವಾಗಿದ್ದರೂ, ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಇದು ಸೀಮಿತವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್‌ಗೆ ಕಾನ್ಫಿಗರೇಶನ್ ಅಗತ್ಯವಿದ್ದಾಗ ಅಥವಾ ಕೆಲವು ಆಂತರಿಕ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ. ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ, FastAPI (Starlette ಮೂಲಕ) BaseHTTPMiddleware ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲಾಸ್-ಆಧಾರಿತ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.
ಕ್ಲಾಸ್-ಆಧಾರಿತ ವಿಧಾನವು ಉತ್ತಮ ರಚನೆಯನ್ನು ನೀಡುತ್ತದೆ, ಅದರ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್‌ಗೆ ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕೀರ್ಣ ತರ್ಕಕ್ಕಾಗಿ ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲದು. ಮುಖ್ಯ ತರ್ಕವು ಅಸಿಂಕ್ರೋನಸ್ dispatch ವಿಧಾನದಲ್ಲಿ ಇರುತ್ತದೆ.
ಉದಾಹರಣೆ: ಕ್ಲಾಸ್-ಆಧಾರಿತ API ಕೀ ದೃಢೀಕರಣ ಮಿಡಲ್‌ವೇರ್
ನಮ್ಮ API ಅನ್ನು ಸುರಕ್ಷಿತಗೊಳಿಸುವ ಹೆಚ್ಚು ಪ್ರಾಯೋಗಿಕ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸೋಣ. ಇದು ನಿರ್ದಿಷ್ಟ ಹೆಡರ್, X-API-Key, ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಕೀ ಇಲ್ಲದಿದ್ದರೆ ಅಥವಾ ಅಮಾನ್ಯವಾಗಿದ್ದರೆ, ಅದು ತಕ್ಷಣವೇ 403 Forbidden ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇದು ರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು "ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್" ಮಾಡುವ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
main.py ನಲ್ಲಿ:
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.responses import Response
# A list of valid API keys. In a real application, this would come from a database or a secure vault.
VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]
class APIKeyMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
api_key = request.headers.get("X-API-Key")
if api_key not in VALID_API_KEYS:
# Short-circuit the request and return an error response
return JSONResponse(
status_code=403,
content={"detail": "Forbidden: Invalid or missing API Key"}
)
# If the key is valid, proceed with the request
response = await call_next(request)
return response
app = FastAPI()
# Add the middleware to the application
app.add_middleware(APIKeyMiddleware)
@app.get("/")
async def root():
return {"message": "Welcome to the secure zone!"}
ಈಗ, ನೀವು ಈ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ:
X-API-Keyಹೆಡರ್ ಇಲ್ಲದ ರಿಕ್ವೆಸ್ಟ್ (ಅಥವಾ ತಪ್ಪಾದ ಮೌಲ್ಯದೊಂದಿಗೆ) 403 ಸ್ಟೇಟಸ್ ಕೋಡ್ ಮತ್ತು JSON ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.X-API-Key: my-super-secret-keyಹೆಡರ್ ಹೊಂದಿರುವ ರಿಕ್ವೆಸ್ಟ್ ಯಶಸ್ವಿಯಾಗುತ್ತದೆ ಮತ್ತು 200 OK ರೆಸ್ಪಾನ್ಸ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
ಈ ಮಾದರಿ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿಯಾಗಿದೆ. / ನಲ್ಲಿರುವ ಎಂಡ್ ಪಾಯಿಂಟ್ ಕೋಡ್ API ಕೀ ವ್ಯಾಲಿಡೇಶನ್ ಬಗ್ಗೆ ಏನನ್ನೂ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ; ಆ ಕಾಳಜಿಯನ್ನು ಮಿಡಲ್‌ವೇರ್ ಲೇಯರ್‌ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಬೇರ್ಪಡಿಸಲಾಗಿದೆ.
ಮಿಡಲ್‌ವೇರ್‌ಗಾಗಿ ಸಾಮಾನ್ಯ ಮತ್ತು ಶಕ್ತಿಶಾಲಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
ಮಿಡಲ್‌ವೇರ್ ಅಡ್ಡ-ಕತ್ತರಿಸುವ ಕಾಳಜಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪರಿಪೂರ್ಣ ಸಾಧನವಾಗಿದೆ. ಕೆಲವು ಸಾಮಾನ್ಯ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
1. ಕೇಂದ್ರೀಕೃತ ಲಾಗಿಂಗ್
ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸಮಗ್ರ ಲಾಗಿಂಗ್ ಅನಿವಾರ್ಯವಾಗಿದೆ. ಮಿಡಲ್‌ವೇರ್ ನಿಮಗೆ ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ಅದರ ಅನುಗುಣವಾದ ರೆಸ್ಪಾನ್ಸ್ ಬಗ್ಗೆ ನಿರ್ಣಾಯಕ ಮಾಹಿತಿಯನ್ನು ಲಾಗ್ ಮಾಡುವ ಒಂದೇ ಪಾಯಿಂಟ್ ಅನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ ಲಾಗಿಂಗ್ ಮಿಡಲ್‌ವೇರ್:
import logging
from fastapi import FastAPI, Request
import time
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
app = FastAPI()
@app.middleware("http")
async def logging_middleware(request: Request, call_next):
start_time = time.time()
# Log request details
logger.info(f"Incoming request: {request.method} {request.url.path}")
response = await call_next(request)
process_time = time.time() - start_time
# Log response details
logger.info(f"Response status: {response.status_code} | Process time: {process_time:.4f}s")
return response
ಈ ಮಿಡಲ್‌ವೇರ್ ಒಳಬರುವ ರಿಕ್ವೆಸ್ಟ್ ವಿಧಾನ ಮತ್ತು ಪಾತ್ ಅನ್ನು, ಮತ್ತು ಹೊರಹೋಗುವ ರೆಸ್ಪಾನ್ಸ್ ಸ್ಟೇಟಸ್ ಕೋಡ್ ಮತ್ತು ಒಟ್ಟು ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯವನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಟ್ರಾಫಿಕ್ ಬಗ್ಗೆ ಅಮೂಲ್ಯವಾದ ಗೋಚರತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
2. ಜಾಗತಿಕ ದೋಷ ನಿರ್ವಹಣೆ
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸದ ವಿನಾಯಿತಿ 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ, ಇದು ಕ್ಲೈಂಟ್‌ಗೆ ಸ್ಟಾಕ್ ಟ್ರೇಸ್‌ಗಳು ಮತ್ತು ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ. ಜಾಗತಿಕ ದೋಷ ನಿರ್ವಹಣಾ ಮಿಡಲ್‌ವೇರ್ ಎಲ್ಲಾ ವಿನಾಯಿತಿಗಳನ್ನು ಹಿಡಿಯಬಹುದು, ಆಂತರಿಕ ಪರಿಶೀಲನೆಗಾಗಿ ಅವುಗಳನ್ನು ಲಾಗ್ ಮಾಡಬಹುದು ಮತ್ತು ಪ್ರಮಾಣಿತ, ಬಳಕೆದಾರ ಸ್ನೇಹಿ ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು.
ಉದಾಹರಣೆ ದೋಷ ನಿರ್ವಹಣಾ ಮಿಡಲ್‌ವೇರ್:
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging
logger = logging.getLogger(__name__)
app = FastAPI()
@app.middleware("http")
async def error_handling_middleware(request: Request, call_next):
try:
return await call_next(request)
except Exception as e:
logger.error(f"An unhandled error occurred: {e}", exc_info=True)
return JSONResponse(
status_code=500,
content={"detail": "An internal server error occurred. Please try again later."}
)
@app.get("/error")
async def cause_error():
return 1 / 0 # This will raise a ZeroDivisionError
ಈ ಮಿಡಲ್‌ವೇರ್ ಇರುವುದರಿಂದ, /error ಗೆ ಮಾಡುವ ರಿಕ್ವೆಸ್ಟ್ ಇನ್ನು ಮುಂದೆ ಸರ್ವರ್ ಅನ್ನು ಕ್ರ್ಯಾಶ್ ಮಾಡುವುದಿಲ್ಲ ಅಥವಾ ಸ್ಟಾಕ್ ಟ್ರೇಸ್ ಅನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಸ್ವಚ್ಛವಾದ JSON ಬಾಡಿಯೊಂದಿಗೆ 500 ಸ್ಟೇಟಸ್ ಕೋಡ್ ಅನ್ನು ಸೌಮ್ಯವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದರೆ ಸಂಪೂರ್ಣ ದೋಷವನ್ನು ಡೆವಲಪರ್‌ಗಳು ತನಿಖೆ ಮಾಡಲು ಸರ್ವರ್-ಸೈಡ್‌ನಲ್ಲಿ ಲಾಗ್ ಮಾಡಲಾಗುತ್ತದೆ.
3. CORS (ಕ್ರಾಸ್-ಒರಿಜಿನ್ ರಿಸೋರ್ಸ್ ಶೇರಿಂಗ್)
ನಿಮ್ಮ ಫ್ರಂಟ್‌ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್ ನಿಮ್ಮ FastAPI ಬ್ಯಾಕೆಂಡ್‌ಗಿಂತ ವಿಭಿನ್ನ ಡೊಮೇನ್, ಪ್ರೋಟೋಕಾಲ್ ಅಥವಾ ಪೋರ್ಟ್‌ನಿಂದ ಸೇವೆ ಸಲ್ಲಿಸಿದ್ದರೆ, Same-Origin Policy ಯಿಂದಾಗಿ ಬ್ರೌಸರ್‌ಗಳು ರಿಕ್ವೆಸ್ಟ್‌ಗಳನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತವೆ. CORS ಈ ನೀತಿಯನ್ನು ಸಡಿಲಗೊಳಿಸುವ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. FastAPI ಇದೇ ಉದ್ದೇಶಕ್ಕಾಗಿ ಮೀಸಲಾದ, ಹೆಚ್ಚು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದಾದ `CORSMiddleware` ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ CORS ಕಾನ್ಫಿಗರೇಶನ್:
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI()
# Define the list of allowed origins. Use "*" for public APIs, but be specific for better security.
origins = [
"http://localhost:3000",
"https://my-production-frontend.com",
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True, # Allow cookies to be included in cross-origin requests
allow_methods=["*"], # Allow all standard HTTP methods
allow_headers=["*"], # Allow all headers
)
ಇದು ವಿಘಟಿತ ಫ್ರಂಟ್‌ಎಂಡ್ ಹೊಂದಿರುವ ಯಾವುದೇ ಯೋಜನೆಗೆ ನೀವು ಬಹುಶಃ ಸೇರಿಸುವ ಮೊದಲ ಮಿಡಲ್‌ವೇರ್‌ಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಇದು ಒಂದೇ, ಕೇಂದ್ರೀಕೃತ ಸ್ಥಳದಿಂದ ಕ್ರಾಸ್-ಒರಿಜಿನ್ ನೀತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸರಳಗೊಳಿಸುತ್ತದೆ.
4. GZip ಕಂಪ್ರೆಷನ್
HTTP ರೆಸ್ಪಾನ್ಸ್‌ಗಳನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವುದರಿಂದ ಅವುಗಳ ಗಾತ್ರವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು, ಇದು ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ವೇಗದ ಲೋಡ್ ಸಮಯ ಮತ್ತು ಕಡಿಮೆ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ವೆಚ್ಚಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. FastAPI ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸಲು `GZipMiddleware` ಅನ್ನು ಒಳಗೊಂಡಿದೆ.
ಉದಾಹರಣೆ GZip ಮಿಡಲ್‌ವೇರ್:
from fastapi import FastAPI
from fastapi.middleware.gzip import GZipMiddleware
app = FastAPI()
# Add the GZip middleware. You can set a minimum size for compression.
app.add_middleware(GZipMiddleware, minimum_size=1000)
@app.get("/")
async def root():
# This response is small and will not be gzipped.
return {"message": "Hello World"}
@app.get("/large-data")
async def large_data():
# This large response will be automatically gzipped by the middleware.
return {"data": "a_very_long_string..." * 1000}
ಈ ಮಿಡಲ್‌ವೇರ್‌ನೊಂದಿಗೆ, 1000 ಬೈಟ್‌ಗಳಿಗಿಂತ ದೊಡ್ಡದಾದ ಯಾವುದೇ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕ್ಲೈಂಟ್ GZip ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಎಂದು ಸೂಚಿಸಿದರೆ (ಇದು ವಾಸ್ತವಿಕವಾಗಿ ಎಲ್ಲಾ ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳು ಮಾಡುತ್ತವೆ) ಅದನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
ನೀವು ಮಿಡಲ್‌ವೇರ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚು ಪ್ರವೀಣರಾದಂತೆ, ಸ್ವಚ್ಛ, ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ಕೋಡ್ ಬರೆಯಲು ಕೆಲವು ಸೂಕ್ಷ್ಮತೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.
1. ಮಿಡಲ್‌ವೇರ್ ಕ್ರಮ ಮುಖ್ಯ!
ನೆನಪಿಡಬೇಕಾದ ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ನಿಯಮ ಇದು. ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸೇರಿಸಿದ ಕ್ರಮದಲ್ಲಿ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸೇರಿಸಿದ ಮೊದಲ ಮಿಡಲ್‌ವೇರ್ "ಈರುಳ್ಳಿಯ" ಹೊರ ಪದರವಾಗಿದೆ.
app.add_middleware(ErrorHandlingMiddleware) # Outermost
app.add_middleware(LoggingMiddleware)
app.add_middleware(AuthenticationMiddleware) # Innermost
ರಿಕ್ವೆಸ್ಟ್‌ನ ಹರಿವು ಹೀಗಿರುತ್ತದೆ:
ErrorHandlingMiddlewareರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಇದು ತನ್ನ `call_next` ಅನ್ನು `try...except` ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸುತ್ತುತ್ತದೆ.- ಇದು `next` ಅನ್ನು ಕರೆಯುತ್ತದೆ, ರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು `LoggingMiddleware` ಗೆ ರವಾನಿಸುತ್ತದೆ.
LoggingMiddlewareರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ ಮತ್ತು `next` ಅನ್ನು ಕರೆಯುತ್ತದೆ.AuthenticationMiddlewareರಿಕ್ವೆಸ್ಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ರುಜುವಾತುಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಮತ್ತು `next` ಅನ್ನು ಕರೆಯುತ್ತದೆ.- ರಿಕ್ವೆಸ್ಟ್ ಅಂತಿಮವಾಗಿ ಎಂಡ್ ಪಾಯಿಂಟ್ ಅನ್ನು ತಲುಪುತ್ತದೆ.
- ಎಂಡ್ ಪಾಯಿಂಟ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
AuthenticationMiddlewareಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮೇಲಕ್ಕೆ ರವಾನಿಸುತ್ತದೆ.LoggingMiddlewareಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಲಾಗ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮೇಲಕ್ಕೆ ರವಾನಿಸುತ್ತದೆ.ErrorHandlingMiddlewareಅಂತಿಮ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಈ ಕ್ರಮ ತಾರ್ಕಿಕವಾಗಿದೆ: ದೋಷ ಹ್ಯಾಂಡ್ಲರ್ ಹೊರಗಿದೆ ಆದ್ದರಿಂದ ಇದು ಯಾವುದೇ ನಂತರದ ಲೇಯರ್‌ನಿಂದ ದೋಷಗಳನ್ನು ಹಿಡಿಯಬಹುದು, ಇತರ ಮಿಡಲ್‌ವೇರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ. ದೃಢೀಕರಣ ಲೇಯರ್ ಆಳದಲ್ಲಿದೆ, ಆದ್ದರಿಂದ ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ತಿರಸ್ಕರಿಸಲಾಗುವ ರಿಕ್ವೆಸ್ಟ್‌ಗಳನ್ನು ಲಾಗಿಂಗ್ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಕ್ಕೆ ನಾವು ತಲೆಕೆಡಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ.
2. request.state ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ರವಾನಿಸುವುದು
ಕೆಲವೊಮ್ಮೆ, ಮಿಡಲ್‌ವೇರ್‌ಗೆ ಎಂಡ್ ಪಾಯಿಂಟ್‌ಗೆ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ದೃಢೀಕರಣ ಮಿಡಲ್‌ವೇರ್ JWT ಅನ್ನು ಡಿಕೋಡ್ ಮಾಡಬಹುದು ಮತ್ತು ಬಳಕೆದಾರರ ID ಅನ್ನು ಹೊರತೆಗೆಯಬಹುದು. ಪಾತ್ ಆಪರೇಷನ್ ಕಾರ್ಯಕ್ಕೆ ಈ ಬಳಕೆದಾರ ID ಅನ್ನು ಹೇಗೆ ಲಭ್ಯವಾಗಿಸಬಹುದು?
ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ನೇರವಾಗಿ ಮಾರ್ಪಡಿಸುವುದು ತಪ್ಪು ವಿಧಾನ. request.state ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುವುದು ಸರಿಯಾದ ಮಾರ್ಗ. ಇದು ಇದೇ ಉದ್ದೇಶಕ್ಕಾಗಿ ಒದಗಿಸಲಾದ ಸರಳ, ಖಾಲಿ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದೆ.
ಉದಾಹರಣೆ: ಮಿಡಲ್‌ವೇರ್‌ನಿಂದ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ರವಾನಿಸುವುದು
# In your authentication middleware's dispatch method:
# ... after validating the token and decoding the user ...
user_data = {"id": 123, "username": "global_dev"}
request.state.user = user_data
response = await call_next(request)
# In your endpoint:
@app.get("/profile")
async def get_user_profile(request: Request):
current_user = request.state.user
return {"profile_for": current_user}
ಇದು ತರ್ಕವನ್ನು ಸ್ವಚ್ಛವಾಗಿರಿಸುತ್ತದೆ ಮತ್ತು `Request` ಆಬ್ಜೆಕ್ಟ್‌ನ ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು ಕಲುಷಿತಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
3. ಕಾರ್ಯಕ್ಷಮತೆ ಪರಿಗಣನೆಗಳು
ಮಿಡಲ್‌ವೇರ್ ಶಕ್ತಿಶಾಲಿಯಾಗಿದ್ದರೂ, ಪ್ರತಿ ಲೇಯರ್ ಸ್ವಲ್ಪ ಪ್ರಮಾಣದ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ಈ ಅಂಶಗಳನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ:
- ಅದನ್ನು ಸರಳವಾಗಿಡಿ: ಮಿಡಲ್‌ವೇರ್ ತರ್ಕವು ಸಾಧ್ಯವಾದಷ್ಟು ವೇಗವಾಗಿ ಮತ್ತು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬೇಕು.
- ಅಸಿಂಕ್ರೋನಸ್ ಆಗಿರಿ: ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್‌ಗೆ I/O ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದರೆ (ಡೇಟಾಬೇಸ್ ಚೆಕ್‌ನಂತೆ), ಸರ್ವರ್‌ನ ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಅದು ಸಂಪೂರ್ಣವಾಗಿ `async` ಆಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬಳಸಿ: ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಸೇರಿಸಬೇಡಿ. ಪ್ರತಿಯೊಂದೂ ಕಾಲ್ ಸ್ಟಾಕ್ ಡೆಪ್ತ್ ಮತ್ತು ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯಕ್ಕೆ ಸೇರಿಸುತ್ತದೆ.
4. ನಿಮ್ಮ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು
ಮಿಡಲ್‌ವೇರ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ತರ್ಕದ ಒಂದು ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಬೇಕು. FastAPI ಯ `TestClient` ಇದನ್ನು ನೇರವಾಗಿ ಮಾಡುತ್ತದೆ. ಅಗತ್ಯವಿರುವ ಷರತ್ತುಗಳೊಂದಿಗೆ ಮತ್ತು ಇಲ್ಲದೆ ರಿಕ್ವೆಸ್ಟ್‌ಗಳನ್ನು ಕಳುಹಿಸುವ (ಉದಾಹರಣೆಗೆ, ಮಾನ್ಯವಾದ API ಕೀಲಿಯೊಂದಿಗೆ ಮತ್ತು ಇಲ್ಲದೆ) ಮತ್ತು ಮಿಡಲ್‌ವೇರ್ ನಿರೀಕ್ಷಿತವಾಗಿ ವರ್ತಿಸುತ್ತದೆ ಎಂದು ದೃಢೀಕರಿಸುವ ಪರೀಕ್ಷೆಗಳನ್ನು ನೀವು ಬರೆಯಬಹುದು.
APIKeyMiddleware ಗಾಗಿ ಉದಾಹರಣೆ ಪರೀಕ್ಷೆ:
from fastapi.testclient import TestClient
from .main import app # Import your FastAPI app
client = TestClient(app)
def test_request_without_api_key_is_forbidden():
response = client.get("/")
assert response.status_code == 403
assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}
def test_request_with_valid_api_key_is_successful():
headers = {"X-API-Key": "my-super-secret-key"}
response = client.get("/", headers=headers)
assert response.status_code == 200
assert response.json() == {"message": "Welcome to the secure zone!"}
ತೀರ್ಮಾನ
FastAPI ಮಿಡಲ್‌ವೇರ್ ಆಧುನಿಕ ವೆಬ್ API ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಯಾವುದೇ ಡೆವಲಪರ್‌ಗೆ ಮೂಲಭೂತ ಮತ್ತು ಶಕ್ತಿಶಾಲಿ ಸಾಧನವಾಗಿದೆ. ಇದು ಅಡ್ಡ-ಕತ್ತರಿಸುವ ಕಾಳಜಿಗಳನ್ನು ನಿಭಾಯಿಸಲು, ಅವುಗಳನ್ನು ನಿಮ್ಮ ಕೋರ್ ವ್ಯವಹಾರ ತರ್ಕದಿಂದ ಬೇರ್ಪಡಿಸಲು ಸೊಗಸಾದ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಪ್ರತಿ ರಿಕ್ವೆಸ್ಟ್ ಮತ್ತು ರೆಸ್ಪಾನ್ಸ್ ಅನ್ನು ಇಂಟರ್‌ಸೆಪ್ಟ್ ಮಾಡುವ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೂಲಕ, ಮಿಡಲ್‌ವೇರ್ ನಿಮಗೆ ದೃಢವಾದ ಲಾಗಿಂಗ್, ಕೇಂದ್ರೀಕೃತ ದೋಷ ನಿರ್ವಹಣೆ, ಕಟ್ಟುನಿಟ್ಟಾದ ಭದ್ರತಾ ನೀತಿಗಳು ಮತ್ತು ಕಂಪ್ರೆಷನ್‌ನಂತಹ ಕಾರ್ಯಕ್ಷಮತೆ ವರ್ಧನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ಸರಳ @app.middleware("http") ಡಿಕೊರೇಟರ್‌ನಿಂದ ಸಂಕೀರ್ಣ, ವರ್ಗ-ಆಧಾರಿತ ಪರಿಹಾರಗಳವರೆಗೆ, ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗಾಗಿ ಸರಿಯಾದ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ನಮ್ಯತೆಯನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ. ಕೋರ್ ಪರಿಕಲ್ಪನೆಗಳು, ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಮಿಡಲ್‌ವೇರ್ ಆರ್ಡರಿಂಗ್ ಮತ್ತು ಸ್ಟೇಟ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ನಂತಹ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಸ್ವಚ್ಛ, ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ FastAPI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು.
ಈಗ ನಿಮ್ಮ ಸರದಿ. ನಿಮ್ಮ ಮುಂದಿನ FastAPI ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಕಸ್ಟಮ್ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಸಂಯೋಜಿಸಲು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ನಿಮ್ಮ API ವಿನ್ಯಾಸದಲ್ಲಿ ಹೊಸ ಮಟ್ಟದ ನಿಯಂತ್ರಣ ಮತ್ತು ಸೊಬಗನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ. ಸಾಧ್ಯತೆಗಳು ಅಗಾಧವಾಗಿವೆ, ಮತ್ತು ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ನಿಸ್ಸಂದೇಹವಾಗಿ ನಿಮ್ಮನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ದಕ್ಷ ಡೆವಲಪರ್ ಆಗಿ ಮಾಡುತ್ತದೆ.